Wie kann ich ein bestimmtes Element aus einem Array entfernen?

1
2
3
4
Nächster
Suchen Sie den Index des Array-Elements, das Sie mit indexOf entfernen möchten, und entfernen Sie diesen Index mit splice.
Die splice () -Methode ändert den Inhalt eines Arrays durch Entfernen
vorhandene Elemente und / oder Hinzufügen neuer Elemente.
const array = [2, 5, 9];
console.log (Array);
const index = array.indexOf (5);
if (Index> -1) {
array.splice (index, 1);
}}
// array = [2, 9]
console.log (Array);
Der zweite Parameter von splice ist die Anzahl der zu entfernenden Elemente. Beachten Sie, dass Splice das vorhandene Array ändert und ein neues Array zurückgibt, das die entfernten Elemente enthält.
Der Vollständigkeit halber sind hier Funktionen aufgeführt. Die erste Funktion entfernt nur ein einzelnes Vorkommen (d. H. Entfernen der ersten Übereinstimmung von 5 aus [2,5,9,1,5,8,5]), während die zweite Funktion alle Vorkommen entfernt:
Funktion removeItemOnce (arr, value) {
var index = arr.indexOf (Wert);
if (Index> -1) {
arr.splice (Index, 1);
}}
return arr;
}}
Funktion removeItemAll (arr, value) {
var i = 0;
while (i  = 0; i--) {
if (Array [i] === Nummer) {
array.splice (i, 1);
}}
}}
Wenn Sie nur das Element am Index erstellen möchten, existiert es nicht mehr, aber Sie möchten nicht, dass sich die Indizes der anderen Elemente ändern:
Array löschen [i];
|
Bearbeitet am Oktober 2016
Mach es einfach, intuitiv und explizit (Occams Rasiermesser)
Mach es unveränderlich (ursprüngliches Array bleibt unverändert)
Tun Sie dies mit Standard-JavaScript-Funktionen, wenn Ihr Browser diese nicht unterstützt - verwenden Sie Polyfill
In diesem Codebeispiel verwende ich die Funktion "array.filter (...)", um unerwünschte Elemente aus einem Array zu entfernen. Diese Funktion ändert das ursprüngliche Array nicht und erstellt ein neues. Wenn Ihr Browser diese Funktion nicht unterstützt (z. B. Internet Explorer vor Version 9 oder Firefox vor Version 1.5), sollten Sie die Filter-Polyfüllung von Mozilla verwenden.
Element entfernen (ECMA-262 Edition 5-Code, auch bekannt als Oldstyle-JavaScript)
var value = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (Funktion (Element) {
Artikel zurückgeben! == Wert
})
console.log (arr)
// [1, 2, 4, 5]
Element entfernen (ECMAScript 6-Code)
sei Wert = 3
sei arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == value)
console.log (arr)
// [1, 2, 4, 5]
WICHTIG Die Pfeilfunktionssyntax von ECMAScript 6 "() => {}" wird in Internet Explorer überhaupt nicht unterstützt, Chrome vor 45, Firefox vor 22 und Safari vor 10. Um die ECMAScript 6-Syntax in alten Browsern zu verwenden, können Sie BabelJS verwenden.
Mehrere Elemente entfernen (ECMAScript 7-Code)
Ein zusätzlicher Vorteil dieser Methode besteht darin, dass Sie mehrere Elemente entfernen können
let forDeletion = [2, 3, 5]
sei arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Lesen Sie weiter unten über array.includes (...) Unterstützung !!!
console.log (arr)
// [1, 4]
WICHTIG Die Funktion "array.includes (...)" wird in Internet Explorer überhaupt nicht unterstützt, Chrome vor Version 47, Firefox vor Version 43, Safari vor Version 9 und Edge vor Version 14. Hier ist also Polyfill von Mozilla.
Entfernen mehrerer Elemente (möglicherweise in Zukunft)
Wenn der Vorschlag "Diese verbindliche Syntax" jemals akzeptiert wird, können Sie Folgendes tun:
// array-lib.js
Exportfunktion remove (... forDeletion) {
return this.filter (item =>! forDeletion.includes (item))
}}
// main.js
{{} aus './array-lib.js' importieren '
sei arr = [1, 2, 3, 4, 5, 3]
// :: Dieser verbindliche Syntaxvorschlag
// Verwenden der Funktion "Entfernen" als "virtuelle Methode"
// ohne Array.prototype zu erweitern
arr = arr :: remove (2, 3, 5)
console.log (arr)
// [1, 4]
Probieren Sie es selbst in BabelJS :)
Referenz
Array.prototype.includes
Funktionale Zusammensetzung
|
Es hängt davon ab, ob Sie einen leeren Platz behalten möchten oder nicht.
Wenn Sie einen leeren Steckplatz möchten:
Array [Index] = undefiniert;
Wenn Sie keinen leeren Steckplatz möchten:
// Um ​​das Original zu behalten:
// oldArray = [... array];
// Dies ändert das Array.
array.splice (index, 1);
Und wenn Sie den Wert dieses Elements benötigen, können Sie einfach das Element des zurückgegebenen Arrays speichern:
var value = array.splice (index, 1) [0];
Wenn Sie an einem Ende des Arrays entfernen möchten, können Sie array.pop () für das letzte oder array.shift () für das erste verwenden (beide geben auch den Wert des Elements zurück).
Wenn Sie den Index des Elements nicht kennen, können Sie ihn mit array.indexOf (item) abrufen (in einem if (), um ein Element abzurufen, oder in einer Weile (), um alle abzurufen). array.indexOf (item) gibt entweder den Index oder -1 zurück, wenn er nicht gefunden wird.
|
Ein Freund hatte Probleme mit Internet Explorer 8 und zeigte mir, was er tat. Ich sagte ihm, dass es falsch sei und er sagte mir, dass er die Antwort bekommen habeHier. Die aktuelle Top-Antwort funktioniert nicht in allen Browsern (z. B. Internet Explorer 8) und entfernt nur das erste Vorkommen des Elements.
Entfernen Sie ALLE Instanzen aus einem Array
Funktion array_remove_index_by_value (arr, item)
{
für (var i = arr.length; i--;)
{
if (arr [i] === item) {arr.splice (i, 1);}
}}
}}
Es durchläuft das Array rückwärts (da sich Indizes und Länge ändern, wenn Elemente entfernt werden) und entfernt das Element, wenn es gefunden wird. Es funktioniert in allen Browsern.
|
Es gibt zwei Hauptansätze:
splice (): anArray.splice (index, 1);
delete: delete anArray [index];
Seien Sie vorsichtig, wenn Sie delete für ein Array verwenden. Es ist gut zum Löschen von Attributen von Objekten, aber nicht so gut für Arrays. Es ist besser, Spleiß für Arrays zu verwenden.
Beachten Sie, dass bei Verwendung von delete für ein Array möglicherweise falsche Ergebnisse für anArray.length angezeigt werden. Mit anderen Worten, Löschen würde das Element entfernen, aber den Wert der Eigenschaft length nicht aktualisieren.
Sie können auch erwarten, dass nach der Verwendung von delete Löcher in den Indexnummern vorhanden sind, z. Möglicherweise haben Sie die Indizes 1, 3, 4, 8, 9 und 11 und die Länge wie vor der Verwendung von delete. In diesem Fall würden alle indizierten for-Schleifen abstürzen, da die Indizes nicht mehr sequentiell sind.
Wenn Sie aus irgendeinem Grund gezwungen sind, delete zu verwenden, sollten Sie für jede Schleife verwenden, wenn Sie Arrays durchlaufen müssen. Vermeiden Sie in der Tat nach Möglichkeit immer die Verwendung von indizierten for-Schleifen. Auf diese Weise wäre der Code robuster und weniger anfällig für Probleme mit Indizes.
|
Array.prototype.remove_by_value = function (val) {
für (var i = 0; i  row.id === 5);
var remove = helper.remove (arr, row => row.name.startsWith ('BMW'));
##Definition
var helper = {
// Das erste Vorkommen entfernen und zurückgeben
removeOne: Funktion (Array, Prädikat) {
für (var i = 0; i  [2, 3, 4]
|
Sie können ES6 verwenden. Zum Beispiel, um den Wert '3' in diesem Fall zu löschen:
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((Wert) => Wert! = '3');
console.log (newArray);
Ausgabe :
["1", "2", "4", "5", "6"]
|
Wenn Sie ein neues Array mit entfernten gelöschten Positionen wünschen, können Sie jederzeit das bestimmte Element löschen und das Array herausfiltern. Für Browser, die die Filtermethode nicht implementieren, ist möglicherweise eine Erweiterung des Array-Objekts erforderlich. Auf lange Sicht ist dies jedoch einfacher, da Sie lediglich Folgendes tun:
var my_array = [1, 2, 3, 4, 5, 6];
lösche my_array [4];
console.log (my_array.filter (Funktion (a) {Rückgabetyp von a! == 'undefined';}));
Es sollte [1, 2, 3, 4, 6] anzeigen.
|
Hier sind einige Möglichkeiten, um ein Element mithilfe von JavaScript aus einem Array zu entfernen.
Alle beschriebenen Methoden mutieren nicht das ursprüngliche Array, sondern erstellen stattdessen ein neues.
Wenn Sie den Index eines Elements kennen
Angenommen, Sie haben ein Array und möchten ein Element an Position i entfernen.
Eine Methode ist die Verwendung von Slice ():
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const i = 3
const filteredItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (gefilterte Elemente)
Slice () erstellt ein neues Array mit den empfangenen Indizes. Wir erstellen einfach ein neues Array vom Anfang bis zum Index, den wir entfernen möchten, und verketten ein anderes Array von der ersten Position nach der Position, die wir entfernt haben, bis zum Ende des Arrays.
Wenn Sie den Wert kennen
In diesem Fall ist die Verwendung von filter () eine gute Option, die einen deklarativeren Ansatz bietet:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filteredItems = items.filter (item => item! == valueToRemove)
console.log (gefilterte Elemente)
Dies verwendet die ES6-Pfeilfunktionen. Sie können die herkömmlichen Funktionen verwenden, um ältere Browser zu unterstützen:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filteredItems = items.filter (Funktion (Element) {
Artikel zurückgeben! == valueToRemove
})
console.log (gefilterte Elemente)
Oder Sie können Babel verwenden und den ES6-Code zurück in ES5 übertragen, um ihn für alte Browser besser verdaulich zu machen, und dennoch modernes JavaScript in Ihren Code schreiben.
Mehrere Elemente entfernen
Was ist, wenn Sie anstelle eines einzelnen Elements viele Elemente entfernen möchten?
Lassen Sie uns die einfachste Lösung finden.
Nach Index
Sie können einfach eine Funktion erstellen und Elemente in Serie entfernen:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const removeItem = (items, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
let filteredItems = removeItem (items, 3)
filteredItems = removeItem (filteredItems, 5)
//["A B C D"]
console.log (gefilterte Elemente)
Nach Wert
Sie können nach der Aufnahme in die Rückruffunktion suchen:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter (item =>! valuesToRemove.includes (item))
// ["a", "b", "e", "f"]
console.log (gefilterte Elemente)
Vermeiden Sie die Mutation des ursprünglichen Arrays
splice () (nicht zu verwechseln mit Slice ()) mutiert das ursprüngliche Array und sollte vermieden werden.
(ursprünglich auf meiner Website https://flaviocopes.com/how-to-remove-item-from-array/ veröffentlicht)
|
Überprüfen Sie diesen Code. Es funktioniert in jedem gängigen Browser.
remove_item = Funktion (arr, Wert) {
var b = '';
für (b in arr) {
if (arr [b] === value) {
arr.splice (b, 1);
brechen;
}}
}}
return arr;
};
Rufen Sie diese Funktion auf
remove_item (Array, Wert);
|
ES6 & ohne Mutation: (Oktober 2016)
const removeByIndex = (Liste, Index) =>
[
... list.slice (0, index),
... list.slice (index + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (Ausgabe)
|
Sie können lodash _.pull (mutiertes Array), _.pullAt (mutiertes Array) oder _.without (mutiertes Array nicht) verwenden.
var array1 = ['a', 'b', 'c', 'd']
_.pull (array1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (array2, 0)
console.log (array2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (array3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['i', 'j', 'k', 'l']
|
Das Entfernen eines bestimmten Elements / Strings aus einem Array kann in einem Einzeiler erfolgen:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
wo:
theArray: Das Array, aus dem Sie etwas Bestimmtes entfernen möchten
stringToRemoveFromArray: Die Zeichenfolge, die entfernt werden soll, und 1 ist die Anzahl der Elemente, die Sie entfernen möchten.
HINWEIS: Wenn sich "stringToRemoveFromArray" nicht in Ihrem Array befindet, wird das letzte Element des Arrays entfernt.
Es ist immer empfehlenswert, zuerst zu überprüfen, ob das Element in Ihrem Array vorhanden ist, bevor Sie es entfernen.
if (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}}
Wenn Sie auf den Computern Ihres Clients Zugriff auf neuere Ecmascript-Versionen haben (WARNUNG, funktioniert möglicherweise nicht auf älteren Stationen):
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((Wert) => Wert! = '3');
Dabei ist '3' der Wert, den Sie aus dem Array entfernen möchten.
Das Array würde dann werden: ['1', '2', '4', '5', '6']
|
OK, zum Beispiel haben Sie das folgende Array:
var num = [1, 2, 3, 4, 5];
Und wir möchten Nummer 4 löschen. Sie können einfach den folgenden Code verwenden:
num.splice (num.indexOf (4), 1); // num wird [1, 2, 3, 5] sein;
Wenn Sie diese Funktion wiederverwenden, schreiben Sie eine wiederverwendbare Funktion, die wie folgt an die native Array-Funktion angehängt wird:
Array.prototype.remove = Array.prototype.remove || Funktion (x) {
const i = this.indexOf (x);
if (i === - 1)
Rückkehr;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}}
Aber wie wäre es, wenn Sie stattdessen das folgende Array mit ein paar [5] s im Array haben?
var num = [5, 6, 5, 4, 5, 1, 5];
Wir brauchen eine Schleife, um sie alle zu überprüfen, aber eine einfachere und effizientere Möglichkeit ist die Verwendung integrierter JavaScript-Funktionen. Deshalb schreiben wir eine Funktion, die stattdessen einen Filter wie den folgenden verwendet:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]
Es gibt auch Bibliotheken von Drittanbietern, die Ihnen dabei helfen, wie Lodash oder Underscore. Weitere Informationen finden Sie unter lodash _.pull, _.pullAt oder _.without.
|
Performance
Heute (09.12.2019) führe ich Leistungstests unter macOS 10.13.6 (High Sierra) für ausgewählte Lösungen durch. Ich zeige delete (A), verwende es aber nicht im Vergleich zu anderen Methoden, da es leeren Platz im Array gelassen hat.
Die Schlussfolgerungen
Die schnellste Lösung ist array.splice (C) (außer Safari für kleine Arrays, bei denen es das zweite Mal ist).
Für große Arrays ist array.slice + splice (H) die schnellste unveränderliche Lösung für Firefox und Safari. Array.from (B) ist in Chrome am schnellsten
veränderbare Lösungen sind normalerweise 1,5x-6x schneller als unveränderlich
Bei kleinen Tabellen auf Safari ist die veränderliche Lösung (C) überraschenderweise langsamer als die unveränderliche Lösung (G).
Einzelheiten
In Tests entferne ich das mittlere Element auf verschiedene Weise aus dem Array. Die A, C-Lösungen sind vorhanden. Die Lösungen B, D, E, F, G, H sind unveränderlich.
Ergebnisse für Array mit 10 Elementen
In Chrome ist array.splice (C) die schnellste direkte Lösung. Der array.filter (D) ist die schnellste unveränderliche Lösung. Das langsamste ist array.slice (F). Hier können Sie den Test auf Ihrem Computer durchführen.
Ergebnisse für Array mit 1.000.000 Elementen
In Chrome ist array.splice (C) die schnellste In-Place-Lösung (das Löschen (C) ist ähnlich schnell - es wurde jedoch ein leerer Steckplatz im Array gelassen (sodass keine vollständige Entfernung durchgeführt wird)). Der array.slice-splice (H) ist die schnellste unveränderliche Lösung. Das langsamste ist array.filter (D und E). Hier können Sie den Test auf Ihrem Computer durchführen.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (Buchstabe, Array) => console.log (Buchstabe, Array.join `,`);
Funktion A (Array) {
var index = array.indexOf (5);
Array löschen [Index];
log ('A', Array);
}}
Funktion B (Array) {
var index = array.indexOf (5);
var arr = Array.from (Array);
arr.splice (Index, 1)
log ('B', arr);
}}
Funktion C (Array) {
var index = array.indexOf (5);
array.splice (index, 1);
log ('C', Array);
}}
Funktion D (Array) {
var arr = array.filter (item => item! == 5)
log ('D', arr);
}}
Funktion E (Array) {
var index = array.indexOf (5);
var arr = array.filter ((item, i) => i! == index)
log ('E', arr);
}}
Funktion F (Array) {
var index = array.indexOf (5);
var arr = array.slice (0, index) .concat (array.slice (index + 1))
log ('F', arr);
}}
Funktion G (Array) {
var index = array.indexOf (5);
var arr = [... array.slice (0, index), ... array.slice (index + 1)]
log ('G', arr);
}}
Funktion H (Array) {
var index = array.indexOf (5);
var arr = array.slice (0);
arr.splice (Index, 1);
log ('H', arr);
}}
A ([... a]);
B ([... a]);
C ([... a]);
D ([... a]);
E ([... a]);
Fa]);
G ([... a]);
Ha]);
Dieses Snippet enthält nur Code, der in Leistungstests verwendet wird. Es führt keine Tests selbst durch.
Vergleich für Browser: Chrome v78.0.0, Safari v13.0.4 und Firefox v71.0.0
|
Ich bin ziemlich neu in JavaScript und brauchte diese Funktionalität. Ich habe nur folgendes geschrieben:
Funktion removeFromArray (Array, Element, Index) {
while ((index = array.indexOf (item))> -1) {
array.splice (index, 1);
}}
}}
Dann, wenn ich es benutzen möchte:
// Einige Dummy-Daten einrichten
var dummyObj = {name: "meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];
// Entfernen Sie die Dummy-Daten
removeFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Ausgabe - Wie erwartet.
["item1", "item1"]
Möglicherweise haben Sie andere Anforderungen als ich, sodass Sie diese problemlos ändern könnenzu ihnen passen. Ich hoffe das hilft jemandem.
|
Wenn Sie komplexe Objekte im Array haben, können Sie Filter verwenden?
In Situationen, in denen $ .inArray oder array.splice nicht so einfach zu verwenden sind. Besonders wenn die Objekte im Array vielleicht flach sind.
Z.B. Wenn Sie ein Objekt mit einem ID-Feld haben und möchten, dass das Objekt aus einem Array entfernt wird:
this.array = this.array.filter (Funktion (Element, i) {
return element.id! == idToRemove;
});
|
Ich möchte basierend auf ECMAScript 6 antworten. Angenommen, Sie haben ein Array wie das folgende:
sei arr = [1,2,3,4];
Wenn Sie an einem speziellen Index wie 2 löschen möchten, schreiben Sie den folgenden Code:
arr.splice (2, 1); // => arr wurde [1,2,4]
Wenn Sie jedoch ein spezielles Element wie 3 löschen möchten und dessen Index nicht kennen, gehen Sie wie folgt vor:
arr = arr.filter (e => e! == 3); // => arr wurde [1,2,4]
Hinweis: Bitte verwenden Sie eine Pfeilfunktion für den Filterrückruf, es sei denn, Sie erhalten ein leeres Array.
|
Update: Diese Methode wird nur empfohlen, wenn Sie ECMAScript 2015 (früher bekannt als ES6) nicht verwenden können. Wenn Sie es verwenden können, bieten andere Antworten hier viel übersichtlichere Implementierungen.
Dieser Kern hier löst Ihr Problem und löscht auch alle Vorkommen des Arguments anstelle von nur 1 (oder einem angegebenen Wert).
Array.prototype.destroy = function (obj) {
// Gibt null zurück, wenn keine Objekte gefunden und entfernt wurden
var zerstört = null;
für (var i = 0; i  3
x.destroy (falsch); // => false
x; // => [1, 2, true, undefined]
x.destroy (wahr); // => wahr
x.destroy (undefiniert); // => undefiniert
x; // => [1, 2]
x.destroy (3); // => null
x; // => [1, 2]
|
ES10-Update
Dieser Beitrag fasst gängige Ansätze zur Elemententfernung aus dem Array ab ECMAScript 2019 (ES10) zusammen.
1. Allgemeine Fälle
1.1. Array-Element mit .splice () nach Wert entfernen
| An Ort und Stelle: Ja |
| Entfernt Duplikate: Ja (Schleife), Nein (IndexOf) |
| Nach Wert / Index: Nach Index |
Wenn Sie den Wert kennen, den Sie aus einem Array entfernen möchten, können Sie die Spleißmethode verwenden. Zuerst müssen Sie den Index des Zielelements identifizieren. Sie verwenden dann den Index als Startelement und entfernen nur ein Element.
// Mit einer 'for'-Schleife
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
für (sei i = 0; i  [1, 2, 3, 4, 6, 7, 8, 9, 0]
// Mit der Methode .indexOf ()
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Entfernen des Array-Elements mit der Methode .filter ()
| An Ort und Stelle: Nein |
| Entfernt Duplikate: Ja |
| Nach Wert / Index: Nach Wert |
Ein bestimmtes Element kann durch Bereitstellen einer Filterfunktion aus dem Array herausgefiltert werden. Eine solche Funktion wird dann für jedes Element im Array aufgerufen.
const value = 3
sei arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item => item! == value)
console.log (arr)
// [1, 2, 4, 5]
1.3. Entfernen des Array-Elements durch Erweitern von Array.prototype
| Vor Ort: Ja / Nein (abhängig von der Implementierung) |
| Entfernt Duplikate: Ja / Nein (abhängig von der Implementierung) |
| Nach Wert / Index: Nach Index / Nach Wert (Abhängig von der Implementierung) |
Der Prototyp des Arrays kann mit zusätzlichen Methoden erweitert werden. Solche Methoden stehen dann für erstellte Arrays zur Verfügung.
Hinweis: Das Erweitern von Prototypen von Objekten aus der Standardbibliothek von JavaScript (wie Array) wird von einigen als Antimuster angesehen.
// In-Place, entfernt alle nach Wertimplementierung
Array.prototype.remove = Funktion (Element) {
für (sei i = 0; i  = ES10)
| An Ort und Stelle: Nein |
| Entfernt Duplikate: Ja |
| Nach Wert / Index: Nach Wert |
ES10 führte Object.fromEntries ein, was sein kannwird verwendet, um das gewünschte Array aus einem Array-ähnlichen Objekt zu erstellen und unerwünschte Elemente während des Prozesses zu filtern.
const object = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values ​​(Object.fromEntries (
Object.entries (Objekt)
.filter (([key, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Sonderfälle
2.1 Element entfernen, wenn es sich am Ende des Arrays befindet
2.1.1. Array-Länge ändern
| An Ort und Stelle: Ja |
| Entfernt Duplikate: Nein |
| Nach Wert / Index: N / A |
JavaScript-Array-Elemente können vom Ende eines Arrays entfernt werden, indem die Eigenschaft length auf einen Wert festgelegt wird, der unter dem aktuellen Wert liegt. Jedes Element, dessen Index größer oder gleich der neuen Länge ist, wird entfernt.
const arr = [1, 2, 3, 4, 5, 6];
arr.length = 5; // Länge einstellen, um Element zu entfernen
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Verwenden der .pop () -Methode
| An Ort und Stelle: Ja |
| Entfernt Duplikate: Nein |
| Nach Wert / Index: N / A |
Die Pop-Methode entfernt das letzte Element des Arrays, gibt dieses Element zurück und aktualisiert die Länge-Eigenschaft. Die Pop-Methode ändert das Array, auf dem es aufgerufen wird. Dies bedeutet, dass im Gegensatz zur Verwendung von delete das letzte Element vollständig entfernt und die Array-Länge reduziert wird.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // gibt 6 zurück
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Element entfernen, wenn es sich am Anfang des Arrays befindet
| An Ort und Stelle: Ja |
| Entfernt Duplikate: Nein |
| Nach Wert / Index: N / A |
Die .shift () -Methode funktioniert ähnlich wie die Pop-Methode, entfernt jedoch das erste Element eines JavaScript-Arrays anstelle des letzten. Wenn das Element entfernt wird, werden die verbleibenden Elemente nach unten verschoben.
const arr = [1, 2, 3, 4];
arr.shift (); // gibt 1 zurück
console.log (arr); // [2, 3, 4]
2.3. Element entfernen, wenn es das einzige Element im Array ist
| An Ort und Stelle: Ja |
| Entfernt Duplikate: N / A |
| Nach Wert / Index: N / A |
Die schnellste Methode besteht darin, eine Array-Variable auf ein leeres Array zu setzen.
sei arr = [1];
arr = []; // leeres Array
Alternativ kann die Technik aus 2.1.1 verwendet werden, indem die Länge auf 0 gesetzt wird.
|
Sie sollten Ihr Array niemals mutieren. Da dies gegen das funktionale Programmiermuster ist. Sie können ein neues Array erstellen, ohne auf das Array zu verweisen, dessen Daten Sie mithilfe des ECMAScript 6-Methodenfilters ändern möchten.
var myArray = [1, 2, 3, 4, 5, 6];
Angenommen, Sie möchten 5 aus dem Array entfernen, dann können Sie dies einfach folgendermaßen tun:
myArray = myArray.filter (Wert => Wert! == 5);
Dadurch erhalten Sie ein neues Array ohne den Wert, den Sie entfernen möchten. Das Ergebnis wird also sein:
[1, 2, 3, 4, 6]; // 5 wurde aus diesem Array entfernt
Zum weiteren Verständnis können Sie die MDN-Dokumentation zu Array.filter lesen.
|
Ein modernerer ECMAScript 2015-Ansatz (früher bekannt als Harmony oder ES 6). Gegeben:
const items = [1, 2, 3, 4];
const index = 2;
Dann:
items.filter ((x, i) => i! == index);
Nachgeben:
[1, 2, 4]
Sie können Babel und einen Polyfill-Dienst verwenden, um sicherzustellen, dass dies in allen Browsern gut unterstützt wird.
|
Sie können eine Rückwärtsschleife ausführen, um sicherzustellen, dass die Indizes nicht durcheinander gebracht werden, wenn mehrere Instanzen des Elements vorhanden sind.
var myElement = "Schokolade";
var myArray = ['Schokolade', 'Poptart', 'Poptart', 'Poptart', 'Schokolade', 'Poptart', 'Poptart', 'Schokolade'];
/ * Wichtiger Code * /
für (var i = myArray.length - 1; i> = 0; i--) {
if (myArray [i] == myElement) myArray.splice (i, 1);
}}
console.log (myArray);
Live-Demo
|
Sie haben 1 bis 9 im Array und möchten 5 entfernen. Verwenden Sie den folgenden Code:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
return m! == 5;
});
console.log ("neues Array, 5 entfernt", newNumberArray);
Wenn Sie mehrere Werte verwenden möchten. Beispiel: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
return (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("neues Array, 1,7 und 8 entfernt", newNumberArray);
Wenn Sie einen Array-Wert in einem Array entfernen möchten. Beispiel: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
return! removebleArray.includes (m);
});
console.log ("neues Array, [3,4,5] entfernt", newNumberArray);
Enthält unterstützten Browser ist Link.
|
1
2
3
4
Nächster
Sehr aktive Frage. Verdiene 10 Reputationen, um diese Frage zu beantworten. Die Reputationsanforderung schützt diese Frage vor Spam und nicht beantworteten Aktivitäten.
Nicht die Antwort, die Sie suchen? Durchsuchen Sie andere Fragen, die mit Javascript-Arrays gekennzeichnet sind, oder stellen Sie Ihre eigene Frage.